﻿using Microsoft.Diagnostics.Tracing;
using Sustainalytics.Admin.Synchronization.Utility;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Sustainalytics.CompanyScreening
{
    [EventSource(Name = "Sustainalytics-ClientPlatform-CompanyScreening")]
    public sealed class CompanyScreeningEventSource : EventSource
    {

        public class Tasks
        {
            public const EventTask RunSelectedCriteria = (EventTask)0x1;
        }

        private static Lazy<CompanyScreeningEventSource> _lazyLog = new Lazy<CompanyScreeningEventSource>(InitLog, LazyThreadSafetyMode.ExecutionAndPublication);

        public CompanyScreeningEventSource() { } // prohibit public instantiation

        public static CompanyScreeningEventSource Log
        {
            get
            {
                return _lazyLog.Value;
            }
        }

        [NonEvent]
        public static CompanyScreeningEventSource InitLog()
        {
            var log = new CompanyScreeningEventSource();
            log.Ping();


            return log;
        }


        [Event(1, Level = EventLevel.LogAlways)]
        public void Ping()
        {
            if (IsEnabled())
                WriteEvent(1);
        }

        [Event(2, Level = EventLevel.Verbose)]
        public void CriteriaTabsLoading()
        {
            if (IsEnabled())
                WriteEvent(2);
        }

        [Event(3, Level = EventLevel.Verbose)]
        public void CriteriaTabsLoaded()
        {
            if (IsEnabled())
                WriteEvent(3);
        }

        [NonEvent]
        public void CriteriaTabLoadingError(Exception exception)
        {
            Guard.ArgumentNotNull(exception, "AddCriteriaTypeOneException");
            if (IsEnabled())
                this.CriteriaTabLoadingError(exception.Message);
        }

        [Event(4, Level = EventLevel.Error)]
        public void CriteriaTabLoadingError(string exceptionMessage)
        {
            WriteEvent(4, exceptionMessage);
        }

        [Event(5, Level = EventLevel.Verbose)]
        public void AddCriteriaTypeOne(Guid templateCriteriaId, int minValue, int maxValue)
        {
            if (IsEnabled())
                WriteEvent(5, templateCriteriaId, minValue, maxValue);
        }

        [Event(6, Level = EventLevel.Verbose)]
        public void AddCriteriaTypeOneSuccess(Guid templateCriteriaId, int minValue, int maxValue)
        {
            if (IsEnabled())
                WriteEvent(6, templateCriteriaId, minValue, maxValue);
        }

        [NonEvent]
        public void AddCriteriaTypeOneError(Guid criteriaId, int minValue, int maxValue, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "AddCriteriaTypeOneException");
            if (IsEnabled())
                this.AddCriteriaTypeOneError(criteriaId, minValue, maxValue, exception.Message);
        }

        [Event(7, Level = EventLevel.Error)]
        public void AddCriteriaTypeOneError(Guid templateCriteriaId, int minValue, int maxValue, string exceptionMessage)
        {
            WriteEvent(7, templateCriteriaId, minValue, maxValue, exceptionMessage);
        }

        [Event(8, Level = EventLevel.Verbose)]
        public void CreateCriteriaTypeOneDto(Guid criteriaId, string criteriaName, int criteriaType)
        {
            if (IsEnabled())
                WriteEvent(8, criteriaId, criteriaName, criteriaType);
        }

        [NonEvent]
        public void CreateCriteriaTypeOneDtoError(Guid criteriaId, string criteriaName, int criteriaType, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "CreateCriteriaTypeOneDtoException");
            if (IsEnabled())
                this.CreateCriteriaTypeOneDtoError(criteriaId, criteriaName, criteriaType, exception.Message);
        }

        [Event(9, Level = EventLevel.Error)]
        public void CreateCriteriaTypeOneDtoError(Guid templateCriteriaId, string criteriaName, int criteriaType, string exception)
        {
            WriteEvent(9, templateCriteriaId, criteriaName, criteriaType, exception);
        }

        [Event(10, Level = EventLevel.Verbose)]
        public void LoadCriteriaTypeOne(Guid templateId)
        {
            if (IsEnabled())
                WriteEvent(10, templateId);
        }

        [Event(11, Level = EventLevel.Verbose)]
        public void LoadCriteriaTypeOneSuccess(Guid templateId)
        {
            if (IsEnabled())
                WriteEvent(11, templateId);
        }

        [NonEvent]
        public void LoadCriteriaTypeOneError(Guid templateId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "LoadCriteriaTypeOneError");
            if (IsEnabled())
                this.LoadCriteriaTypeOneError(templateId, exception.Message);
        }

        [Event(12, Level = EventLevel.Error)]
        public void LoadCriteriaTypeOneError(Guid templateId, string exception)
        {
            WriteEvent(12, templateId, exception);
        }

        [Event(13, Level = EventLevel.Verbose)]
        public void UpdateCriteriaTypeOne(Guid criteriaId, int minValue, int maxValue)
        {
            if (IsEnabled())
                WriteEvent(13, criteriaId, minValue, maxValue);
        }

        [Event(14, Level = EventLevel.Verbose)]
        public void UpdateCriteriaTypeOneSuccess(Guid criteriaId, int minValue, int maxValue)
        {
            if (IsEnabled())
                WriteEvent(14, criteriaId, minValue, maxValue);
        }

        [NonEvent]
        public void UpdateCriteriaTypeOneError(Guid criteriaId, int minValue, int maxValue, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "UpdateCriteriaTypeOneException");
            if (IsEnabled())
                this.UpdateCriteriaTypeOneError(criteriaId, minValue, maxValue, exception.Message);
        }

        [Event(15, Level = EventLevel.Error)]
        public void UpdateCriteriaTypeOneError(Guid criteriaId, int minValue, int maxValue, string exceptionMessage)
        {
            if (IsEnabled())
                WriteEvent(15, criteriaId, minValue, maxValue);
        }

        [Event(16, Level = EventLevel.Verbose)]
        public void CreateCriteriaTypeOne(int minValue, int maxValue, Guid filterId)
        {
            if (IsEnabled())
                WriteEvent(16, minValue, maxValue, filterId);
        }

        [Event(17, Level = EventLevel.Verbose)]
        public void ListBaseCriteria()
        {
            if (IsEnabled())
                WriteEvent(17);
        }

        [NonEvent]
        public void ListBaseCriteriaError(Exception exception)
        {
            Guard.ArgumentNotNull(exception, "ListBaseCriteriaException");
            if (IsEnabled())
                this.ListBaseCriteriaError(exception.Message);
        }

        [Event(18, Level = EventLevel.Error)]
        public void ListBaseCriteriaError(string exceptionMessage)
        {
            WriteEvent(18, exceptionMessage);
        }

        [Event(19, Level = EventLevel.Verbose)]
        public void ListCriteriaLevelOne()
        {
            if (IsEnabled())
                WriteEvent(19);
        }

        [NonEvent]
        public void ListCriteriaLevelOneError(Exception exception)
        {
            Guard.ArgumentNotNull(exception, "ListCriteriaLevelOneException");
            if (IsEnabled())
                this.ListCriteriaLevelOneError(exception.Message);
        }

        [Event(20, Level = EventLevel.Error)]
        public void ListCriteriaLevelOneError(string exeptionMessage)
        {
            WriteEvent(20, exeptionMessage);
        }

        [Event(21, Level = EventLevel.Verbose)]
        public void ListCriteriaLevelTwo()
        {
            if (IsEnabled())
                WriteEvent(21);
        }

        [NonEvent]
        public void ListCriteriaLevelTwoError(Exception exception)
        {
            Guard.ArgumentNotNull(exception, "ListCriteriaLevelTwoException");
            if (IsEnabled())
                ListCriteriaLevelTwoError(exception.Message);

        }

        [Event(22, Level = EventLevel.Error)]
        public void ListCriteriaLevelTwoError(string exceptionMessage)
        {
            WriteEvent(22, exceptionMessage);
        }

        [Event(23, Level = EventLevel.Verbose)]
        public void ComputeClusters(string criteriaEntity, string criteriaEntityField)
        {
            if (IsEnabled())
                WriteEvent(23, criteriaEntity, criteriaEntityField);
        }

        [Event(24, Level = EventLevel.Verbose)]
        public void LoadCriteriaTypeOneData(string criteriaEntity, string criteriaEntityField)
        {
            if (IsEnabled())
                WriteEvent(24, criteriaEntity, criteriaEntityField);
        }

        [NonEvent]
        public void LoadCriteriaTypeOneDataError(string criteriaEntity, string criteriaEntityField, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "LoadCriteriaTypeOneDataException");
            if (IsEnabled())
                this.LoadCriteriaTypeOneDataError(criteriaEntity, criteriaEntityField, exception.Message);

        }

        [Event(25, Level = EventLevel.Error)]
        public void LoadCriteriaTypeOneDataError(string criteriaEntity, string criteriaEntityField, string exceptionMessage)
        {
            WriteEvent(25, criteriaEntity, criteriaEntityField, exceptionMessage);
        }

        [Event(26, Level = EventLevel.Verbose)]
        public void SaveCriteriaResults(Guid criteriaId, int criteriaType, int companyIdsCount)
        {
            if (IsEnabled())
                WriteEvent(26, criteriaId, criteriaType, companyIdsCount);
        }

        [NonEvent]
        public void SaveCriteriaResultsError(Guid criteriaId, int criteriaType, int companyIdsCount, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "SaveCriteriaResultsException");
            if (IsEnabled())
                this.SaveCriteriaResultsError(criteriaId, criteriaType, companyIdsCount, exception.Message);
        }

        [Event(27, Level = EventLevel.Error)]
        public void SaveCriteriaResultsError(Guid criteriaId, int criteriaType, int companyIdsCount, string exceptionMessage)
        {
            WriteEvent(27, criteriaId, criteriaType, companyIdsCount, exceptionMessage);
        }

        [Event(28, Level = EventLevel.Verbose)]
        public void ProcessCriteriaTypeOne(string criteriaEntity, string criteriaEntityField, int minValue, int maxValue)
        {
            if (IsEnabled())
                WriteEvent(28, criteriaEntity, criteriaEntityField, minValue, maxValue);
        }

        [NonEvent]
        public void ProcessCriteriaTypeOneError(string criteriaEntity, string criteriaEntityField, int minValue, int maxValue, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "ProcessCriteriaTypeOneException");
            if (IsEnabled())
                this.ProcessCriteriaTypeOneError(criteriaEntity, criteriaEntityField, minValue, maxValue, exception.Message);
        }

        [Event(29, Level = EventLevel.Error)]
        public void ProcessCriteriaTypeOneError(string criteriaEntity, string criteriaEntityField, int minValue, int maxValue, string exceptionMessage)
        {
            WriteEvent(29, criteriaEntity, criteriaEntityField, minValue, maxValue, exceptionMessage);
        }

        [Event(30, Level = EventLevel.Informational)]
        public void LoadCriteriaTypeTwo(Guid templateId)
        {
            if (IsEnabled())
                WriteEvent(30, templateId);
        }

        [Event(31, Level = EventLevel.Verbose)]
        public void LoadCriteriaTypeTwoSuccess(Guid templateId)
        {
            if (IsEnabled())
                WriteEvent(31, templateId);
        }

        [NonEvent]
        public void LoadCriteriaTypeTwoError(Guid templateId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "LoadCriteriaTypeTwoError");
            if (IsEnabled())
                this.LoadCriteriaTypeTwoError(templateId, exception.Message);
        }

        [Event(32, Level = EventLevel.Error)]
        private void LoadCriteriaTypeTwoError(Guid templateId, string exception)
        {
            WriteEvent(32, templateId, exception);
        }

        [Event(33, Level = EventLevel.Verbose)]
        public void AddCriteriaTypeTwo(Guid templateCriteriaId, int score)
        {
            if (IsEnabled())
                WriteEvent(33, templateCriteriaId, score);
        }

        [Event(34, Level = EventLevel.Verbose)]
        public void AddCriteriaTypeTwoSuccess(Guid templateCriteriaId, int score)
        {
            if (IsEnabled())
                WriteEvent(34, templateCriteriaId, score);
        }

        [NonEvent]
        public void AddCriteriaTypeTwoError(Guid criteriaId, int score, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "AddCriteriaTypeTwoError");
            if (IsEnabled())
                this.AddCriteriaTypeTwoError(criteriaId, score, exception.Message);
        }

        [Event(35, Level = EventLevel.Error)]
        private void AddCriteriaTypeTwoError(Guid templateCriteriaId, int score, string exceptionMessage)
        {
            WriteEvent(35, templateCriteriaId, score, exceptionMessage);
        }

        [Event(36, Level = EventLevel.Verbose)]
        public void UpdateCriteriaTypeTwo(Guid templateCriteriaId, int score)
        {
            if (IsEnabled())
                WriteEvent(36, templateCriteriaId, score);
        }

        [Event(37, Level = EventLevel.Verbose)]
        public void UpdateCriteriaTypeTwoSuccess(Guid templateCriteriaId, int score)
        {
            if (IsEnabled())
                WriteEvent(37, templateCriteriaId, score);
        }

        [NonEvent]
        public void UpdateCriteriaTypeTwoError(Guid criteriaId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "UpdateCriteriaTypeTwoError");
            if (IsEnabled())
                this.UpdateCriteriaTypeTwoError(criteriaId, exception.Message);
        }

        [Event(38, Level = EventLevel.Error)]
        private void UpdateCriteriaTypeTwoError(Guid templateCriteriaId, string exceptionMessage)
        {
            WriteEvent(38, templateCriteriaId, exceptionMessage);
        }

        [Event(39, Level = EventLevel.Verbose)]
        public void GetCurrentFilter()
        {
            if (IsEnabled())
                WriteEvent(39);
        }

        [Event(40, Level = EventLevel.Verbose)]
        public void GetCurrentFilterSuccess(string username)
        {
            if (IsEnabled())
                WriteEvent(40, username);
        }

        [NonEvent]
        public void GetCurrentFilterError(Exception exception)
        {
            Guard.ArgumentNotNull(exception, "GetCurrentFilterError");
            if (IsEnabled())
                this.GetCurrentFilterError(exception.Message);
        }

        [Event(41, Level = EventLevel.Error)]
        private void GetCurrentFilterError(string exceptionMessage)
        {
            WriteEvent(41, exceptionMessage);
        }
        [Event(42, Level = EventLevel.Verbose)]
        public void InitAccountsController()
        {
            if (IsEnabled())
                WriteEvent(42);
        }

        [Event(43, Level = EventLevel.Verbose)]
        public void InitAccountsControllerSuccess()
        {
            if (IsEnabled())
                WriteEvent(43);
        }

        [NonEvent]
        public void InitAccountsControllerError(Exception exception)
        {
            Guard.ArgumentNotNull(exception, "InitAccountsControllerError");
            if (IsEnabled())
                this.InitAccountsControllerError(exception.Message);
        }

        [Event(44, Level = EventLevel.Error)]
        private void InitAccountsControllerError(string exceptionMessage)
        {
            WriteEvent(44, exceptionMessage);
        }

        [Event(45, Level = EventLevel.Informational)]
        public void AddCriteriaTypeTwoService(Guid templateId, string username)
        {
            if (IsEnabled())
                WriteEvent(45, templateId, username);
        }

        [Event(46, Level = EventLevel.Informational)]
        public void LoadCriteriaTypeTwoService(Guid templateId)
        {
            if (IsEnabled())
                WriteEvent(46, templateId);
        }

        [Event(47, Level = EventLevel.Informational)]
        public void UpdateCriteriaTypeTwoService(Guid criteriaId)
        {
            if (IsEnabled())
                WriteEvent(47, criteriaId);
        }

        [Event(48, Level = EventLevel.Informational)]
        public void ProcessCriteriaTypeTwoService(string criteriaEntity, string criteriaEntityField)
        {
            if (IsEnabled())
                WriteEvent(48, criteriaEntity, criteriaEntityField);
        }

        [Event(49, Level = EventLevel.Error)]
        public void ProcessCriteriaTypeTwoServiceError(string exceptionMessage)
        {
            if (IsEnabled())
                WriteEvent(49, exceptionMessage);
        }

        [Event(50, Level = EventLevel.Informational)]
        public void DeleteCriteria(Guid criteriaId)
        {
            if (IsEnabled())
                WriteEvent(50, criteriaId);
        }

        [Event(51, Level = EventLevel.Verbose)]
        public void DeleteCriteriaSuccess(Guid criteriaId)
        {
            if (IsEnabled())
                WriteEvent(51, criteriaId);
        }

        [NonEvent]
        public void DeleteCriteriaError(Guid criteriaId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "DeleteCriteriaError");
            if (IsEnabled())
                DeleteCriteriaError(criteriaId, exception.Message);
        }

        [Event(52, Level = EventLevel.Error)]
        public void DeleteCriteriaError(Guid criteriaId, string errorMessage)
        {
            WriteEvent(52, criteriaId, errorMessage);
        }

        [NonEvent]
        public void UpdateSelectedCriteriaOrderNumberError(Guid filterId, List<Guid> criteriaIds, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "UpdateSelectedCriteriaOrderNumberError");
            if (IsEnabled())
                UpdateSelectedCriteriaOrderNumberError(filterId, string.Join(",", criteriaIds), exception.Message);
        }

        [Event(53, Level = EventLevel.Error)]
        public void UpdateSelectedCriteriaOrderNumberError(Guid filterId, string criteriaIds, string exceptionMessage)
        {
            WriteEvent(53, filterId, criteriaIds, exceptionMessage);
        }

        [Event(54, Level = EventLevel.Verbose)]
        public void ListSelectedCriteriaTypeOne(Guid filterId)
        {
            if (IsEnabled())
                WriteEvent(54, filterId);
        }

        [Event(55, Level = EventLevel.Verbose)]
        public void ListSelectedCriteriaTypeTwo(Guid filterId)
        {
            if (IsEnabled())
                WriteEvent(55, filterId);
        }

        [Event(56, Level = EventLevel.Verbose)]
        public void ListSelectedCriteriaTypeThree(Guid filterId)
        {
            if (IsEnabled())
                WriteEvent(56, filterId);
        }

        [Event(57, Level = EventLevel.Verbose)]
        public void ListSelectedCriteriaSuccess(Guid filterId)
        {
            if (IsEnabled())
                WriteEvent(57, filterId);
        }

        [NonEvent]
        public void ListSelectedCriteriaTypeOneError(Guid filterId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "ListSelectedCriteriaTypeOneError");
            if (IsEnabled())
                ListSelectedCriteriaTypeOneError(filterId, exception.Message);
        }

        [Event(58, Level = EventLevel.Verbose)]
        public void ListSelectedCriteriaTypeOneError(Guid filterId, string exceptionMessage)
        {
            WriteEvent(58, filterId);
        }

        [NonEvent]
        public void ListSelectedCriteriaTypeTwoError(Guid filterId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "ListSelectedCriteriaTypeTwoError");
            if (IsEnabled())
                ListSelectedCriteriaTypeTwoError(filterId, exception.Message);
        }

        [Event(59, Level = EventLevel.Verbose)]
        public void ListSelectedCriteriaTypeTwoError(Guid filterId, string exceptionMessage)
        {
            WriteEvent(59, filterId);
        }

        [NonEvent]
        public void ListSelectedCriteriaTypeThreeError(Guid filterId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "ListSelectedCriteriaTypeThreeError");
            if (IsEnabled())
                ListSelectedCriteriaTypeThreeError(filterId, exception.Message);
        }

        [Event(60, Level = EventLevel.Verbose)]
        public void ListSelectedCriteriaTypeThreeError(Guid filterId, string exceptionMessage)
        {
            WriteEvent(60, filterId);
        }

        [Event(61, Level = EventLevel.Verbose)]
        public void AddCriteriaTypeThree(Guid templateCriteriaId, string collectionName)
        {
            if (IsEnabled())
                WriteEvent(61, templateCriteriaId, collectionName);
        }

        [Event(62, Level = EventLevel.Verbose)]
        public void AddCriteriaTypeThreeSuccess(Guid templateCriteriaId, string collectionName)
        {
            if (IsEnabled())
                WriteEvent(62, templateCriteriaId, collectionName);
        }

        [NonEvent]
        public void AddCriteriaTypeThreeError(Guid criteriaId, string collectionName, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "AddCriteriaTypeThreeError");
            if (IsEnabled())
                this.AddCriteriaTypeThreeError(criteriaId, collectionName, exception.Message);
        }

        [Event(63, Level = EventLevel.Error)]
        private void AddCriteriaTypeThreeError(Guid templateCriteriaId, string collectionName, string exceptionMessage)
        {
            WriteEvent(63, templateCriteriaId, collectionName, exceptionMessage);
        }

        [Event(64, Level = EventLevel.Verbose)]
        public void UpdateCriteriaTypeThree(Guid criteriaTemplateId, string collectionName)
        {
            if (IsEnabled())
                WriteEvent(64, criteriaTemplateId, collectionName);
        }

        [Event(65, Level = EventLevel.Verbose)]
        public void UpdateCriteriaTypeThreeSuccess(Guid templateCriteriaId, string collectionName)
        {
            if (IsEnabled())
                WriteEvent(65, templateCriteriaId, collectionName);
        }

        [NonEvent]
        public void UpdateCriteriaTypeThreeError(Guid criteriaId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "UpdateCriteriaTypeThreeError");
            if (IsEnabled())
                UpdateCriteriaTypeThreeError(criteriaId, exception.Message);
        }

        [Event(66, Level = EventLevel.Error)]
        private void UpdateCriteriaTypeThreeError(Guid templateCriteriaId, string exceptionMessage)
        {
            WriteEvent(66, templateCriteriaId, exceptionMessage);
        }


        [Event(67, Level = EventLevel.Verbose)]
        public void LoadCriteriaTypeThree(Guid criteriaTemplateId)
        {
            if (IsEnabled())
                WriteEvent(67, criteriaTemplateId);
        }

        [Event(68, Level = EventLevel.Verbose)]
        public void LoadCriteriaTypeThreeSuccess(Guid templateCriteriaId)
        {
            if (IsEnabled())
                WriteEvent(68, templateCriteriaId);
        }

        [NonEvent]
        public void LoadCriteriaTypeThreeError(Guid criteriaId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "LoadCriteriaTypeThreeError");
            if (IsEnabled())
                LoadCriteriaTypeThreeError(criteriaId, exception.Message);
        }

        [Event(69, Level = EventLevel.Error)]
        private void LoadCriteriaTypeThreeError(Guid templateCriteriaId, string exceptionMessage)
        {
            WriteEvent(69, templateCriteriaId, exceptionMessage);
        }

        [Event(70, Level = EventLevel.Verbose)]
        public void BaseCriteriasLoading()
        {
            if (IsEnabled())
                WriteEvent(70);
        }

        [Event(71, Level = EventLevel.Verbose)]
        public void BaseCriteriasLoaded()
        {
            if (IsEnabled())
                WriteEvent(71);
        }

        [NonEvent]
        public void BaseCriteriasLoadingError(Exception exception)
        {
            Guard.ArgumentNotNull(exception, "AddCriteriaTypeOneException");
            if (IsEnabled())
                this.BaseCriteriasLoadingError(exception.Message);
        }

        [Event(72, Level = EventLevel.Error)]
        public void BaseCriteriasLoadingError(string exceptionMessage)
        {
            WriteEvent(72, exceptionMessage);
        }

        [Event(73, Level = EventLevel.Verbose)]
        public void GetCriteriaByID(Guid criteriaId)
        {
            if (IsEnabled())
                WriteEvent(73, criteriaId);
        }

        [NonEvent]
        public void GetCriteriaByIDError(Guid criteriaId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "GetCriteriaByIDErrorEsception");
            if (IsEnabled())
                this.GetCriteriaByIDError(criteriaId, exception.Message);
        }

        [Event(74, Level = EventLevel.Error)]
        public void GetCriteriaByIDError(Guid criteriaId, string exceptionMessage)
        {
            WriteEvent(74, criteriaId, exceptionMessage);
        }

        [Event(75, Level = EventLevel.Verbose)]
        public void ProcessCriteriaTypeThree(string criteriaEntity, string criteriaEntityField)
        {
            if (IsEnabled())
                WriteEvent(75, criteriaEntity, criteriaEntityField);
        }

        [NonEvent]
        public void ProcessCriteriaTypeThreeError(string criteriaEntity, string criteriaEntityField, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "ProcessCriteriaTypeThreeException");
            if (IsEnabled())
                this.ProcessCriteriaTypeThreeError(criteriaEntity, criteriaEntityField, exception.Message);
        }

        [Event(76, Level = EventLevel.Error)]
        public void ProcessCriteriaTypeThreeError(string criteriaEntity, string criteriaEntityField, string exceptionMessage)
        {
            WriteEvent(76, criteriaEntity, criteriaEntityField, exceptionMessage);
        }

        [NonEvent]
        public void SelectedCriteriaManagerHubError(Exception exception)
        {
            Guard.ArgumentNotNull(exception, "SelectedCriteriaManagerHubError");
            if (IsEnabled())
                this.SelectedCriteriaManagerHubError(exception.Message);
        }

        [Event(77, Level = EventLevel.Error)]
        public void SelectedCriteriaManagerHubError(string exceptionMessage)
        {
            WriteEvent(77, exceptionMessage);
        }

        [Event(78, Level = EventLevel.Verbose)]
        public void GetCompaniesCountByCriteriaType(Guid criteriaId, int criteriaType)
        {
            if (IsEnabled())
                WriteEvent(78, criteriaId, criteriaType);
        }

        [NonEvent]
        public void GetCompaniesCountByCriteriaTypeError(Guid criteriaId, int criteriaType, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "GetCompaniesCountByCriteriaTypeError");
            if (IsEnabled())
                this.GetCompaniesCountByCriteriaTypeError(criteriaId, criteriaType, exception.Message);
        }

        [Event(79, Level = EventLevel.Error)]
        public void GetCompaniesCountByCriteriaTypeError(Guid criteriaId, int criteriaType, string exceptionMessage)
        {
            WriteEvent(79, criteriaId, criteriaType, exceptionMessage);
        }

        [Event(80, Level = EventLevel.Informational)]
        public void LoadCriteriaTypeFive(Guid templateId)
        {
            if (IsEnabled())
                WriteEvent(80, templateId);
        }

        [Event(81, Level = EventLevel.Verbose)]
        public void LoadCriteriaTypeFiveSuccess(Guid templateId)
        {
            if (IsEnabled())
                WriteEvent(81, templateId);
        }

        [NonEvent]
        public void LoadCriteriaTypeFiveError(Guid templateId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "LoadCriteriaTypeFiveError");
            if (IsEnabled())
                this.LoadCriteriaTypeFiveError(templateId, exception.Message);
        }

        [Event(82, Level = EventLevel.Error)]
        private void LoadCriteriaTypeFiveError(Guid templateId, string exception)
        {
            WriteEvent(82, templateId, exception);
        }

        [Event(83, Level = EventLevel.Verbose)]
        public void AddCriteriaTypeFive(Guid templateCriteriaId, int score, string templateIndicatorNumber)//todo petre check logging
        {
            if (IsEnabled())
                WriteEvent(83, templateCriteriaId, score, templateIndicatorNumber);
        }

        [Event(84, Level = EventLevel.Verbose)]
        public void AddCriteriaTypeFiveSuccess(Guid templateCriteriaId, int score, string templateIndicatorNumber)
        {
            if (IsEnabled())
                WriteEvent(84, templateCriteriaId, score, templateIndicatorNumber);
        }

        [NonEvent]
        public void AddCriteriaTypeFiveError(Guid criteriaId, int score, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "AddCriteriaTypeFiveError");
            if (IsEnabled())
                this.AddCriteriaTypeFiveError(criteriaId, score, exception.Message);
        }

        [Event(85, Level = EventLevel.Error)]
        private void AddCriteriaTypeFiveError(Guid templateCriteriaId, int score, string exceptionMessage)
        {
            WriteEvent(85, templateCriteriaId, score, exceptionMessage);
        }

        [Event(86, Level = EventLevel.Verbose)]
        public void UpdateCriteriaTypeFive(Guid templateCriteriaId, int score, string templateIndicatorNumber)
        {
            if (IsEnabled())
                WriteEvent(86, templateCriteriaId, score, templateIndicatorNumber);
        }

        [Event(87, Level = EventLevel.Verbose)]
        public void UpdateCriteriaTypeFiveSuccess(Guid templateCriteriaId, int score, string templateIndicatorNumber)
        {
            if (IsEnabled())
                WriteEvent(87, templateCriteriaId, score, templateIndicatorNumber);
        }

        [NonEvent]
        public void UpdateCriteriaTypeFiveError(Guid criteriaId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "UpdateCriteriaTypeFiveError");
            if (IsEnabled())
                this.UpdateCriteriaTypeFiveError(criteriaId, exception.Message);
        }

        [Event(88, Level = EventLevel.Error)]
        private void UpdateCriteriaTypeFiveError(Guid templateCriteriaId, string exceptionMessage)
        {
            WriteEvent(88, templateCriteriaId, exceptionMessage);
        }

        [Event(89, Level = EventLevel.Informational)]
        public void AddCriteriaTypeFiveService(Guid templateId, string username)
        {
            if (IsEnabled())
                WriteEvent(89, templateId, username);
        }

        [Event(90, Level = EventLevel.Informational)]
        public void LoadCriteriaTypeFiveService(Guid templateId)
        {
            if (IsEnabled())
                WriteEvent(90, templateId);
        }

        [Event(91, Level = EventLevel.Informational)]
        public void UpdateCriteriaTypeFiveService(Guid criteriaId)
        {
            if (IsEnabled())
                WriteEvent(91, criteriaId);
        }

        [Event(92, Level = EventLevel.Informational)]
        public void ProcessCriteriaTypeFiveService(string criteriaEntity, string criteriaEntityField)
        {
            if (IsEnabled())
                WriteEvent(92, criteriaEntity, criteriaEntityField);
        }

        [Event(93, Level = EventLevel.Error)]
        public void ProcessCriteriaTypeFiveServiceError(string exceptionMessage)
        {
            if (IsEnabled())
                WriteEvent(93, exceptionMessage);
        }

        [Event(94, Level = EventLevel.Verbose)]
        public void ListSelectedCriteriaTypeFive(Guid filterId)
        {
            if (IsEnabled())
                WriteEvent(94, filterId);
        }


        [NonEvent]
        public void ListSelectedCriteriaTypeFiveError(Guid filterId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "ListSelectedCriteriaTypeFiveError");
            if (IsEnabled())
                ListSelectedCriteriaTypeFiveError(filterId, exception.Message);
        }


        [Event(95, Level = EventLevel.Verbose)]
        public void ListSelectedCriteriaTypeFiveError(Guid filterId, string exceptionMessage)
        {
            WriteEvent(95, filterId);
        }



        [Event(96, Level = EventLevel.Verbose)]
        public void GetLastUsedFilters()
        {
            if (IsEnabled())
                WriteEvent(96);
        }

        [Event(97, Level = EventLevel.Error)]
        public void UserNotAuthenticated()
        {
            if (IsEnabled())
                WriteEvent(97);
        }


        [Event(98, Level = EventLevel.Error)]
        public void UserNotFound(string userName)
        {
            if (IsEnabled())
                WriteEvent(98, userName);
        }


        [Event(99, Level = EventLevel.Verbose)]
        public void ProcessCriteriaTypeFive(string criteriaEntity, string criteriaEntityField)
        {
            if (IsEnabled())
                WriteEvent(99, criteriaEntity, criteriaEntityField);
        }

        [NonEvent]
        public void ProcessCriteriaTypeFiveError(string criteriaEntity, string criteriaEntityField, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "ProcessCriteriaTypeFiveException");
            if (IsEnabled())
                this.ProcessCriteriaTypeFiveError(criteriaEntity, criteriaEntityField, exception.Message);
        }

        [Event(100, Level = EventLevel.Error)]
        public void ProcessCriteriaTypeFiveError(string criteriaEntity, string criteriaEntityField, string exceptionMessage)
        {
            WriteEvent(100, criteriaEntity, criteriaEntityField, exceptionMessage);
        }

        [Event(101, Level = EventLevel.Informational)]
        public void UpdateSelectedCriteriaOrderNumber(Guid filterId, string criteriaIds)
        {
            if (IsEnabled())
                WriteEvent(101, filterId, criteriaIds);
        }

        [Event(102, Level = EventLevel.Informational)]
        public void UpdateSelectedCriteriaOrderNumberSuccess(Guid filterId, string criteriaIds)
        {
            if (IsEnabled())
                WriteEvent(102, filterId, criteriaIds);
        }

        [Event(103, Level = EventLevel.Informational, Opcode = EventOpcode.Start, Task = Tasks.RunSelectedCriteria)]
        public void RunSelectedCriteria(Guid filterId)
        {
            if (IsEnabled())
                WriteEvent(103, filterId);
        }

        [Event(104, Level = EventLevel.Informational, Opcode = EventOpcode.Stop, Task = Tasks.RunSelectedCriteria)]
        public void RunSelectedCriteriaSuccess(Guid filterId)
        {
            if (IsEnabled())
                WriteEvent(104, filterId);
        }

        [NonEvent]
        public void RunSelectedCriteriaError(Guid filterId, Exception ex)
        {
            Guard.ArgumentNotNull(ex, "ex");

            if (IsEnabled())
                this.RunSelectedCriteriaError(filterId, ex.Message);
        }

        [Event(105, Level = EventLevel.Error)]
        public void RunSelectedCriteriaError(Guid filterId, string exMsg)
        {
            if (IsEnabled())
                WriteEvent(105, filterId, exMsg);
        }

        [Event(106, Level = EventLevel.Informational)]
        public void GetResultOutput(Guid filterId, bool isValid, bool isValidIsNull, int pageIndex, int pageSize, string orderBy, bool asc)
        {
            if (IsEnabled())
                WriteEvent(106, filterId, isValid, isValidIsNull, pageIndex, pageSize, orderBy, asc);
        }

        [Event(107, Level = EventLevel.Informational)]
        public void GetResultOutputSuccess(Guid filterId, bool isValid, bool isValidIsNull, int pageIndex, int pageSize, string orderBy, bool asc)
        {
            if (IsEnabled())
                WriteEvent(107, filterId, isValid, isValidIsNull, pageIndex, pageSize, orderBy, asc);
        }

        [NonEvent]
        public void GetResultOutputError(Guid filterId, bool isValid, bool isValidIsNull, int pageIndex, int pageSize, string orderBy, bool asc, Exception ex)
        {
            Guard.ArgumentNotNull(ex, "ex");

            if (IsEnabled())
                this.GetResultOutputError(filterId, isValid, isValidIsNull, pageIndex, pageSize, orderBy, asc, ex.Message);
        }

        [Event(108, Level = EventLevel.Error)]
        public void GetResultOutputError(Guid filterId, bool isValid, bool isValidIsNull, int pageIndex, int pageSize, string orderBy, bool asc, string exMsg)
        {
            if (IsEnabled())
                WriteEvent(108, filterId, isValid, isValidIsNull, pageIndex, pageSize, orderBy, asc, exMsg);
        }

        [Event(109, Level = EventLevel.Informational)]
        public void DeleteAllCriteria(Guid filterId)
        {
            if (IsEnabled())
                WriteEvent(109, filterId);
        }

        [Event(110, Level = EventLevel.Informational)]
        public void DeleteAllCriteriaSuccess(Guid filterId)
        {
            if (IsEnabled())
                WriteEvent(110, filterId);
        }

        [NonEvent]
        public void DeleteAllCriteriaError(Guid filterId, Exception ex)
        {
            if (IsEnabled())
                this.DeleteAllCriteriaError(filterId, ex.Message);
        }

        [Event(111, Level = EventLevel.Error)]
        public void DeleteAllCriteriaError(Guid filterId, string exMsg)
        {
            if (IsEnabled())
                WriteEvent(111, filterId, exMsg);
        }

        [NonEvent]
        public void PersistScreeningFilterActionWarning(Exception exception)
        {
            if (!IsEnabled())
                return;

            PersistScreeningFilterActionWarning(exception.Message);
        }

        [Event(112, Level = EventLevel.Warning)]
        public void PersistScreeningFilterActionWarning(string message)
        {
            if (!IsEnabled())
                return;

            WriteEvent(112, message);
        }

        [Event(113, Level = EventLevel.Error)]
        public void CurrentFilterInconsistenData(System.Guid filterId, System.Guid userId, System.Guid rootFilterId)
        {
            if (!IsEnabled())
                return;

            WriteEvent(113, filterId, userId, rootFilterId);
        }

        [Event(114, Level = EventLevel.Warning)]
        public void SaveFilterValidationFailed(string userName, string filterName, bool shared, bool createNew)
        {
            if (!IsEnabled())
                return;

            WriteEvent(114, userName, filterName, shared, createNew);
        }

        [Event(115, Level = EventLevel.Error)]
        public void SaveFilterAuthorizationFailed(string userName, string filterName, bool shared, bool createNew)
        {
            if (!IsEnabled())
                return;

            WriteEvent(115, userName, filterName, shared, createNew);
        }

        [Event(116, Level = EventLevel.Informational)]
        public void ClearResultOutput(Guid filterId)
        {
            if (IsEnabled())
            {
                WriteEvent(116, filterId);
            }
        }

        [Event(117, Level = EventLevel.Informational)]
        public void ClearResultOutputSuccess(Guid filterId)
        {
            if (IsEnabled())
            {
                WriteEvent(117, filterId);
            }
        }

        [NonEvent]
        public void ClearResultOutputError(Guid filterId, Exception ex)
        {
            Guard.ArgumentNotNull(ex, "ex");

            if (IsEnabled())
            {
                ClearResultOutputError(filterId, ex.Message);
            }
        }

        [Event(118, Level = EventLevel.Error)]
        public void ClearResultOutputError(Guid filterId, string errMsg)
        {
            if (IsEnabled())
            {
                WriteEvent(118, filterId, errMsg);
            }
        }

        [NonEvent]
        public void GetUserFiltersError(string userName, Exception exception)
        {
            if (!IsEnabled())
                return;

            GetUserFiltersError(userName, Utils.ExceptionUtility.GetInfo(exception));
        }

        [Event(200, Level = EventLevel.Error)]
        public void GetUserFiltersError(string userName, string message)
        {
            if (!IsEnabled())
                return;

            WriteEvent(200, userName, message);
        }

        [Event(201, Level = EventLevel.Informational)]
        public void GetUserFilters(string userName)
        {
            if (!IsEnabled())
                return;

            WriteEvent(201, userName);
        }

        [Event(202, Level = EventLevel.LogAlways)]
        public void LoadFilterAuthorizationFailed(string userName, Guid rootFilterId)
        {
            if (!IsEnabled())
                return;

            WriteEvent(202, userName, rootFilterId);
        }


        [Event(300, Level = EventLevel.Informational)]
        public void LoadTemplateCriteriaTypeFive(Guid templateId)
        {
            if (IsEnabled())
                WriteEvent(300, templateId);
        }

        [Event(301, Level = EventLevel.Verbose)]
        public void LoadTemplateCriteriaTypeFiveSuccess(Guid templateId)
        {
            if (IsEnabled())
                WriteEvent(301, templateId);
        }

        [NonEvent]
        public void LoadTemplateCriteriaTypeFiveError(Guid templateId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "LoadCriteriaTypeFiveError");
            if (IsEnabled())
                this.LoadCriteriaTypeFiveError(templateId, exception.Message);
        }

        [Event(302, Level = EventLevel.Error)]
        private void LoadTemplateCriteriaTypeFiveError(Guid templateId, string exception)
        {
            WriteEvent(302, templateId, exception);
        }

        [Event(303, Level = EventLevel.Informational)]
        public void LoadTemplateCriteriaTypeFiveService(Guid templateId)
        {
            if (IsEnabled())
                WriteEvent(303, templateId);
        }

        [Event(304, Level = EventLevel.Informational)]
        public void GetFullResultOutput(Guid filterId, bool isValid, bool isValidIsNull)
        {
            if (IsEnabled())
                WriteEvent(304, filterId, isValid, isValidIsNull);
        }

        [Event(305, Level = EventLevel.Informational)]
        public void GetFullResultOutputSuccess(Guid filterId, bool isValid, bool isValidIsNull)
        {
            if (IsEnabled())
                WriteEvent(305, filterId, isValid, isValidIsNull);
        }

        [NonEvent]
        public void GetFullResultOutputError(Guid filterId, bool isValid, bool isValidIsNull, Exception ex)
        {
            Guard.ArgumentNotNull(ex, "ex");

            if (IsEnabled())
                this.GetFullResultOutputError(filterId, isValid, isValidIsNull, ex);
        }

        [Event(306, Level = EventLevel.Error)]
        public void GetFullResultOutputError(Guid filterId, bool isValid, bool isValidIsNull, string exMsg)
        {
            if (IsEnabled())
                WriteEvent(306, filterId, isValid, isValidIsNull, exMsg);
        }

        [Event(600, Level = EventLevel.Verbose)]
        public void ProcessCriteriaTypeSix(string criteriaEntity, string criteriaEntityField, int minValue, int maxValue, Guid matrixId)
        {
            if (IsEnabled())
                WriteEvent(600, criteriaEntity, criteriaEntityField, minValue, maxValue, matrixId.ToString());
        }

        [NonEvent]
        public void ProcessCriteriaTypeSixError(string criteriaEntity, string criteriaEntityField, int minValue, int maxValue, Guid matrixId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "ProcessCriteriaTypeSixException");
            if (IsEnabled())
                this.ProcessCriteriaTypeSixError(criteriaEntity, criteriaEntityField, minValue, maxValue, matrixId, exception.Message);
        }

        [Event(601, Level = EventLevel.Error)]
        public void ProcessCriteriaTypeSixError(string criteriaEntity, string criteriaEntityField, int minValue, int maxValue, Guid matrixId, string exceptionMessage)
        {
            WriteEvent(601, criteriaEntity, criteriaEntityField, minValue, maxValue, matrixId.ToString(), exceptionMessage);
        }

        [Event(602, Level = EventLevel.Verbose)]
        public void LoadCriteriaTypeSix(Guid criteriaTemplateId)
        {
            if (IsEnabled())
                WriteEvent(602, criteriaTemplateId.ToString());
        }

        [Event(603, Level = EventLevel.Verbose)]
        public void LoadCriteriaTypeSixSuccess(Guid criteriaTemplateId)
        {
            if (IsEnabled())
                WriteEvent(603, criteriaTemplateId.ToString());
        }

        [NonEvent]
        public void LoadCriteriaTypeSixError(Guid criteriaTemplateId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "LoadCriteriaTypeSixException");
            if (IsEnabled())
                this.LoadCriteriaTypeSixError(criteriaTemplateId, exception.Message);
        }

        [Event(604, Level = EventLevel.Error)]
        public void LoadCriteriaTypeSixError(Guid criteriaTemplateId, string exceptionMessage)
        {
            WriteEvent(604, criteriaTemplateId.ToString(), exceptionMessage);
        }

        [Event(605, Level = EventLevel.Verbose)]
        public void CreateCriteriaTypeSix(int minValue, int maxValue, Guid matrixId, Guid filterId)
        {
            if (IsEnabled())
                WriteEvent(605, minValue, maxValue, matrixId, filterId);
        }

        [NonEvent]
        public void ListSelectedCriteriaTypeSixError(Guid filterId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "ListSelectedCriteriaTypeSixException");
            if (IsEnabled())
                this.ListSelectedCriteriaTypeSixError(filterId, exception.Message);
        }

        [Event(606, Level = EventLevel.Error)]
        public void ListSelectedCriteriaTypeSixError(Guid filterId, string exceptionMessage)
        {
            WriteEvent(606, filterId.ToString(), exceptionMessage);
        }

        [Event(607, Level = EventLevel.Verbose)]
        public void LoadCriteriaTypeSixData(string criteriaEntity, string criteriaEntityField)
        {
            WriteEvent(607, criteriaEntity, criteriaEntityField);
        }

        [NonEvent]
        public void LoadCriteriaTypeSixDataError(string criteriaEntity, string criteriaEntityField, Guid matrixId, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "LoadCriteriaTypeSixDataException");
            if (IsEnabled())
                this.LoadCriteriaTypeSixDataError(criteriaEntity, criteriaEntityField, matrixId.ToString(), exception.Message);
        }

        [Event(608, Level = EventLevel.Error)]
        public void LoadCriteriaTypeSixDataError(string criteriaEntity, string criteriaEntityField, string matrixId, string exceptionMessage)
        {
            WriteEvent(608, criteriaEntity, criteriaEntityField, matrixId, exceptionMessage);
        }

        [Event(609, Level = EventLevel.Verbose)]
        public void AddCriteriaTypeSix(Guid templateCriteriaId, int minValue, int maxValue)
        {
            if (IsEnabled())
                WriteEvent(609, templateCriteriaId, minValue, maxValue);
        }

        [Event(610, Level = EventLevel.Verbose)]
        public void AddCriteriaTypeSixSuccess(Guid templateCriteriaId, int minValue, int maxValue)
        {
            if (IsEnabled())
                WriteEvent(610, templateCriteriaId, minValue, maxValue);
        }

        [NonEvent]
        public void AddCriteriaTypeSixError(Guid criteriaId, int minValue, int maxValue, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "AddCriteriaTypeSixException");
            if (IsEnabled())
                this.AddCriteriaTypeSixError(criteriaId, minValue, maxValue, exception.Message);
        }

        [Event(611, Level = EventLevel.Error)]
        public void AddCriteriaTypeSixError(Guid templateCriteriaId, int minValue, int maxValue, string exceptionMessage)
        {
            WriteEvent(611, templateCriteriaId, minValue, maxValue, exceptionMessage);
        }

        [Event(612, Level = EventLevel.Verbose)]
        public void UpdateCriteriaTypeSix(Guid criteriaId, int minValue, int maxValue)
        {
            if (IsEnabled())
                WriteEvent(612, criteriaId, minValue, maxValue);
        }

        [Event(613, Level = EventLevel.Verbose)]
        public void UpdateCriteriaTypeSixSuccess(Guid criteriaId, int minValue, int maxValue)
        {
            if (IsEnabled())
                WriteEvent(613, criteriaId, minValue, maxValue);
        }

        [NonEvent]
        public void UpdateCriteriaTypeSixError(Guid criteriaId, int minValue, int maxValue, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "UpdateCriteriaTypeSixException");
            if (IsEnabled())
                this.UpdateCriteriaTypeSixError(criteriaId, minValue, maxValue, exception.Message);
        }

        [Event(614, Level = EventLevel.Error)]
        public void UpdateCriteriaTypeSixError(Guid criteriaId, int minValue, int maxValue, string exceptionMessage)
        {
            if (IsEnabled())
                WriteEvent(614, criteriaId, minValue, maxValue);
        }

        [Event(615, Level = EventLevel.Verbose)]
        public void CreateCriteriaTypeSixDto(Guid criteriaId, string criteriaName, int criteriaType)
        {
            if (IsEnabled())
                WriteEvent(615, criteriaId, criteriaName, criteriaType);
        }

        [NonEvent]
        public void CreateCriteriaTypeSixDtoError(Guid criteriaId, string criteriaName, int criteriaType, Exception exception)
        {
            Guard.ArgumentNotNull(exception, "CreateCriteriaTypeSixDtoException");
            if (IsEnabled())
                this.CreateCriteriaTypeSixDtoError(criteriaId, criteriaName, criteriaType, exception.Message);
        }

        [Event(616, Level = EventLevel.Error)]
        public void CreateCriteriaTypeSixDtoError(Guid templateCriteriaId, string criteriaName, int criteriaType, string exception)
        {
            WriteEvent(616, templateCriteriaId, criteriaName, criteriaType, exception);
        }

        [Event(617, Level = EventLevel.Verbose)]
        public void ListSelectedCriteriaTypeSix(Guid filterId)
        {
            if (IsEnabled())
                WriteEvent(617, filterId);
        }
    }
}
